const SupplierModel = require("../model/SupplierModel");
const CategoryModel = require("../model/CategoryModel");

// 正则
// 电话号码
const PHONE_REGEX = /^1[3-9]\d{9}$/;
// 银行账号
const BANK_ACCOUNT_REGEX = /^\d{10,30}$/;
// 允许中文、字母、数字、空格、括号、减号、斜杠，至少2个字符
const NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9\s()（）-]{2,100}$/;

class SupplierController {
  constructor() {
    this.supplierModel = new SupplierModel();
    this.categoryModel = new CategoryModel();
    this.categoryMap = null; // 用于缓存分类 ID -> Name 的映射表
  }
  // 分类映射表
  async _ensureCategoryMapLoaded() {
    if (!this.categoryMap) {
      const categories = await this.categoryModel.getCategoryList();
      // 使用 cate_id 作为 Key，name 作为 Value
      this.categoryMap = categories.reduce((map, item) => {
        map[item.cate_id] = item.name;
        return map;
      }, {});
    }
  }
  // 辅助校验
  _validateSupplierData(data, isUpdate = false) {
    const errors = {};
    // 必填字段校验
    if (!isUpdate) {
      if (!data.supplier_name) errors.supplier_name = "供应商名称不能为空";
      if (!data.contact_person) errors.contact_person = "联系人不能为空";
      if (!data.cate_ids || data.cate_ids.length === 0)
        errors.cate_ids = "供应商至少需要选择一个分类";
    }
    // 多选分类校验
    if (data.cate_ids !== undefined) {
      if (!Array.isArray(data.cate_ids) || data.cate_ids.length === 0) {
        errors.cate_ids = "分类ID必须是至少包含一个整数的数组";
      } else {
        // 确保数组中的元素都是有效数字
        const invalidId = data.cate_ids.find((id) => isNaN(parseInt(id)));
        if (invalidId) {
          errors.cate_ids = "分类ID数组中包含无效的值";
        }
        // 确保 cate_ids 最终是纯整数数组，以便 Model 处理
        data.cate_ids = data.cate_ids.map((id) => parseInt(id));
      }
    }
    // 正则校验
    if (data.supplier_name && !NAME_REGEX.test(data.supplier_name)) {
      errors.supplier_name = "供应商名称格式不正确";
    }

    if (data.phone && data.phone !== null && !PHONE_REGEX.test(data.phone)) {
      errors.phone = "联系电话格式不正确";
    }

    if (
      data.bank_account &&
      data.bank_account !== null &&
      !BANK_ACCOUNT_REGEX.test(data.bank_account)
    ) {
      errors.bank_account = "银行账号格式不正确";
    }

    return errors;
  }
  // 获取供应商列表 (GET /supplier)
  async getSuppliers(req, res) {
    const { page, pageSize, keyword, status, rating, cate_ids, contactPerson } =
      req.query;

    let filterStatus = status;
    if (
      filterStatus === undefined ||
      filterStatus === null ||
      filterStatus === "active"
    ) {
      filterStatus = "active";
    }

    try {
      const result = await this.supplierModel.getAllSuppliers({
        page: parseInt(page) || 1,
        pageSize: parseInt(pageSize) || 10,
        keyword,
        status: filterStatus,
        rating,
        cate_ids: cate_ids,
        contactPerson: contactPerson,
      });
      // 确保分类映射表被加载
      await this._ensureCategoryMapLoaded();
      // 数据富集：将 cate_ids (ID数组) 转换为 cate_names (名称数组)
      const enrichedDataList = result.data.map((supplier) => {
        const cateNames = supplier.cate_ids.map((id) => {
          return this.categoryMap[id] || `未知分类 (${id})`;
        });
        return {
          ...supplier,
          cate_names: cateNames, // 添加分类名称数组
        };
      });
      // 成功响应 200
      return res.status(200).json({
        code: 0,
        msg: "success",
        data: {
          total: result.total,
          data: enrichedDataList,
          page: result.page,
          pageSize: result.pageSize,
        },
      });
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "获取供应商列表失败。" });
    }
  }
  // 获取单个供应商详情 (GET /supplier/:id)
  async getSupplierDetail(req, res) {
    const supplierId = parseInt(req.params.id);
    if (isNaN(supplierId)) {
      // 参数错误响应 400
      return res.status(400).json({ code: 1, msg: "供应商ID无效。" });
    }

    try {
      let data = await this.supplierModel.getSupplierById(supplierId);

      if (!data) {
        // 资源未找到响应 404
        return res.status(404).json({ code: 1, msg: "供应商不存在。" });
      }
      // 确保分类映射表被加载
      await this._ensureCategoryMapLoaded();
      // 数据富集：添加 cate_names 字段
      const cateNames = data.cate_ids.map((id) => {
        return this.categoryMap[id] || `未知分类 (${id})`;
      });

      data = {
        ...data,
        cate_names: cateNames,
      };
      // 成功响应 200
      return res.status(200).json({ code: 0, msg: "success", data });
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "获取供应商详情失败。" });
    }
  }
  // 新增供应商 (POST /supplier)
  async createSupplier(req, res) {
    const data = req.body;
    // 格式、必填字段校验
    const validationErrors = this._validateSupplierData(data, false);
    if (Object.keys(validationErrors).length > 0) {
      // 校验错误响应 400
      return res
        .status(400)
        .json({ code: 1, msg: Object.values(validationErrors)[0] });
    }
    // 业务校验：名称唯一性
    try {
      const nameExist = await this.supplierModel.isNameExist(
        data.supplier_name
      );
      if (nameExist) {
        // 业务冲突响应 400
        return res.status(400).json({ code: 1, msg: "供应商名称已存在。" });
      }
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "名称唯一性检查失败。" });
    }
    // 数据库操作
    try {
      const insertId = await this.supplierModel.addSupplier(data);
      // 资源创建成功响应 201
      return res.status(201).json({
        code: 0,
        msg: "新增供应商成功",
        data: { supplier_id: insertId },
      });
    } catch (err) {
      console.error(err.message);

      if (err.message.includes("供应商名称已存在")) {
        // 业务冲突响应 400
        return res.status(400).json({ code: 1, msg: "供应商名称已存在。" });
      } // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "新增供应商失败。" });
    }
  }
  // 更新供应商信息 (PUT /supplier/:id)
  async updateSupplier(req, res) {
    const supplierId = parseInt(req.params.id);
    const data = req.body;
    // 基础参数检查
    if (isNaN(supplierId) || Object.keys(data).length === 0) {
      // 参数错误响应 400
      return res
        .status(400)
        .json({ code: 1, msg: "ID无效或没有提供更新数据。" });
    } // 阻止修改已删除的供应商
    const newStatus =
      data.status !== undefined ? parseInt(data.status) : undefined;

    try {
      // 获取供应商当前状态
      const currentSupplier = await this.supplierModel.getSupplierById(
        supplierId
      );

      if (!currentSupplier) {
        // 资源未找到响应 404
        return res.status(404).json({ code: 1, msg: "供应商不存在。" });
      }

      const currentStatus = currentSupplier.status;

      if (currentStatus === -1) {
        // 如果当前状态是逻辑删除 (status=-1)
        // 且请求中没有明确将状态恢复到 1 (正常)
        if (newStatus === undefined || newStatus !== 1) {
          // 检查请求体中是否还有其他字段
          const hasOtherFields = Object.keys(data).some(
            (key) => key !== "status"
          );

          if (hasOtherFields || (newStatus !== undefined && newStatus !== 1)) {
            // 冻结保护响应 400
            return res.status(400).json({
              code: 1,
              msg: "供应商已终止合作，除非明确将状态恢复为 1 (正常)，否则无法修改其他信息。",
            });
          }
        }
      }
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "更新前的状态检查失败。" });
    } // 状态校验
    if (newStatus !== undefined) {
      // 校验 status 必须是 0, 1, 或 -1 之一
      if (isNaN(newStatus) || ![0, 1, -1].includes(newStatus)) {
        // 校验错误响应 400
        return res
          .status(400)
          .json({ code: 1, msg: "更新的状态值无效。状态必须为 0, 1, 或 -1。" });
      }
      data.status = newStatus;
    }
    // 格式校验 (包括名称、电话、银行账号、cate_ids)
    const validationErrors = this._validateSupplierData(data, true);
    if (Object.keys(validationErrors).length > 0) {
      // 校验错误响应 400
      return res
        .status(400)
        .json({ code: 1, msg: Object.values(validationErrors)[0] });
    }
    // 名称唯一性 (排除自身)
    if (data.supplier_name) {
      try {
        const nameExist = await this.supplierModel.isNameExist(
          data.supplier_name,
          supplierId
        );
        if (nameExist) {
          // 业务冲突响应 400
          return res
            .status(400)
            .json({ code: 1, msg: "更新的供应商名称已存在。" });
        }
      } catch (err) {
        console.error(err.message);
        // 内部错误响应 500
        return res.status(500).json({ code: 1, msg: "名称唯一性检查失败。" });
      }
    }
    // 数据库操作
    try {
      const updateSuccess = await this.supplierModel.updateSupplier(
        supplierId,
        data
      );

      if (!updateSuccess) {
        // 资源未找到或未更改响应 404
        return res
          .status(404)
          .json({ code: 1, msg: "数据没有改变或供应商不存在。" });
      }
      // 响应消息
      let msg = "供应商信息更新成功";
      if (newStatus !== undefined) {
        // 如果请求体中包含 status 字段，优先使用状态变更消息
        if (newStatus === -1) {
          msg = "供应商已终止合作";
        } else if (newStatus === 0) {
          msg = "供应商已暂停合作";
        } else if (newStatus === 1) {
          msg = "供应商已恢复正常合作";
        }
      } // 成功响应 200
      return res.status(200).json({ code: 0, msg: msg });
    } catch (err) {
      console.error(err.message);

      if (err.message.includes("供应商名称已存在")) {
        // 业务冲突响应 400
        return res
          .status(400)
          .json({ code: 1, msg: "更新的供应商名称已存在。" });
      }
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "更新供应商信息失败。" });
    }
  }
  // 获取分类列表 (GET /supplier/categories)
  async getSupplierCategories(req, res) {
    try {
      const list = await this.categoryModel.getCategoryList();
      // 将数据库字段 cate_id/name 映射为通用的 id/name
      const formattedList = list.map((item) => ({
        id: item.cate_id,
        name: item.name,
        order: item.cate_order,
      }));
      // 成功响应 200
      return res.status(200).json({
        code: 0,
        msg: "success",
        data: formattedList,
      });
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "获取商品分类失败。" });
    }
  }

  // 软删除/终止合作供应商 (DELETE /supplier/:id)
  async deactivateSupplier(req, res) {
    const supplierId = parseInt(req.params.id);

    if (isNaN(supplierId)) {
      // 参数错误响应 400
      return res.status(400).json({ code: 1, msg: "供应商ID无效。" });
    }

    try {
      // 检查供应商是否存在
      const currentSupplier = await this.supplierModel.getSupplierById(
        supplierId
      );

      if (!currentSupplier) {
        // 资源未找到响应 404
        return res.status(404).json({ code: 1, msg: "供应商不存在。" });
      } // 如果供应商已经是 -1 (终止合作)，则无需重复操作

      if (currentSupplier.status === -1) {
        return res.status(400).json({
          code: 1,
          msg: "该供应商已是终止合作状态，无需重复操作。",
        });
      }
      // 执行软删除：设置 status = -1
      const dataToUpdate = { status: -1 };
      const updateSuccess = await this.supplierModel.updateSupplier(
        supplierId,
        dataToUpdate
      );

      if (!updateSuccess) {
        // 如果 updateSuccess 为 false
        return res
          .status(500)
          .json({ code: 1, msg: "终止合作操作失败，请重试。" });
      }
      // 成功响应 200
      return res.status(200).json({
        code: 0,
        msg: "供应商已终止合作（软删除）",
      });
    } catch (err) {
      console.error(err.message);
      // 内部错误响应 500
      return res.status(500).json({ code: 1, msg: "处理供应商终止合作失败。" });
    }
  }
}

module.exports = SupplierController;
